#define _CRT_SECURE_NO_WARNINGS

//for (int i = 0; i < n; i++) // i 的范围就是 [0,n) , 也就是一个左闭右开的区间
//for (auto it = v.begin(); it < v.end(); it++) // 迭代器 it 的范围也是一个左闭右开的区间

//set<int> s = { ... };
//set<int>::iterator it1 = s.lower_bound(a);
//set<int>::iterator it2 = s.upper_bound(b);
//for (; it1 < it2; it1++) // 这样就可以在节点值为 [a,b) 的区间内遍历了
//{
//    ...
//}


//set<int> s = { 2,4,6,8,10,12 };
//set<int>::iterator it1 = s.lower_bound(3); // 传递的参数 val 可以不在该 set 中
//set<int>::iterator it2 = s.upper_bound(9); // 传递的参数 val 可以不在该 set 中
//// it1 会指向值为 4 的结点
//// it2 会指向值为 10 的结点

//// (1)
//void erase(iterator position); // 删除 position 指向的那个结点
//
//// (2)
//size_type erase(const value_type& val); // 删除所有值为 val 的结点, 返回删除的结点个数
//
//// (3)
//void erase(iterator first, iterator last); // 删除一段迭代器区间 [first,last) 的结点

//#include <vector>
//#include <set>
//
//using namespace std;
//
//class Solution
//{
//public:
//    vector<int> intersection(vector<int>& nums1, vector<int>& nums2)
//    {
//        set<int> s1(nums1.begin(), nums1.end());
//        set<int> s2(nums2.begin(), nums2.end());
//        vector<int> v;
//        for (auto e : s1)
//        {
//            if (s2.count(e)) v.push_back(e);
//        }
//        return v;
//    }
//};
//
//template
//<
//    class Key,
//    class T,
//    class Compare = less<Key>,
//    class Alloc = allocator<pair<const Key, T>> // 内存分配器
//>
//class map;
//
//template <class T1, class T2>
//struct pair
//{
//    typedef T1 first_type;
//    typedef T2 second_type;
//    T1 first;
//    T2 second;
//    pair() : first(T1()), second(T2())
//    {
//    }
//    pair(const T1& a, const T2& b) : first(a), second(b)
//    {
//    }
//    template<class U, class V>
//    pair(const pair<U, V>& pr) : first(pr.first), second(pr.second)
//    {
//    }
//};
//template <class T1, class T2>
//inline pair<T1, T2> make_pair(T1 x, T2 y)
//{
//    return (pair<T1, T2>(x, y));
//}



//// Definition for a Node.
//class Node {
//public:
//    int val;
//    Node* next;
//    Node* random;
//
//    Node(int _val)
//    {
//        val = _val;
//        next = NULL;
//        random = NULL;
//    }
//};
//
//
//Node* getnode(int val)
//{
//    Node* ret = new Node(val);
//    return ret;
//}
//
//class Solution
//{
//public:
//    Node* copyRandomList(Node* head)
//    {
//        map<Node*, Node*> m;
//        Node* cur = head;
//        Node* rethead;
//        Node* cur2 = getnode(0);
//        rethead = cur->next;
//        for (cur = head; cur != nullptr; cur = cur->next)
//        {
//            cur2->next = getnode(cur->val);
//            cur2 = cur2->next;
//            if (cur == head) rethead = cur2;
//        }
//        cur2->next = nullptr;
//        for (cur = head, cur2 = rethead; cur != nullptr; cur = cur->next, cur2 = cur2->next)
//        {
//            m.insert({ cur, cur2 });
//        }
//        for (cur = head, cur2 = rethead; cur != nullptr; cur = cur->next, cur2 = cur2->next)
//        {
//            cur2->random = m.find(cur->random)->second;
//        }
//        return rethead;
//    }
//};


//int main()
//{
//    map<int, char> m1;
//    map<int, char> m2;
//
//    pair<int, char> p = { 1,'a' };
//    m1.insert(p); // 创建有名对象作为实参, 这么麻烦的方法不会真有人用吧
//
//    m1.insert(pair<int, char>(2, 'b')); // 创建匿名对象作为实参, 除了用来说明自己知道匿名对象, 有人会这么用吗? 
//
//    m1.insert(make_pair<int, char>(3, 'c')); // 使用 make_pair 返回的临时对象作为实参, 我感觉这样做实在是太冷门了
//
//    // 多参数构造函数支持隐式类型转换 (如果没使用explicit) 修饰
//    m1.insert({ 4,'d' }); // 由于 map 类内置实现了多参数构造函数, 借助隐式类型转换传参
//    // 十分方便, 往死里用
//
//    m2.insert(m1.lower_bound(1), m1.upper_bound(4)); // 借助区间构建函数确定区间, 实现插入一个区间内的值
//    // 上面这个示例会插入键 key 的值在 [1,4) 内的键值对
//
//    return 0;
//}

#include <iostream>
#include <string>
#include <vector>
#include <map>
using namespace std;

int main()
{
    map<char, int> m;
    m.insert({ 'a',1 });
    m.insert({ 'b',2 });
    m.insert({ 'c',3 });

    cout << m['a'] << m['b'] << m['c'] << endl;
    m['a']++;
    m['b'] = 114514;
    m['c'] = 1919810;
    cout << m['a'] << endl;
    cout << m['b'] << endl;
    cout << m['c'] << endl;

    return 0;
}